package com.ruoyi.controller;

import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.entity.JrTemplates;
import com.ruoyi.entity.vo.OnlyOfficeCallbackDTO;
import com.ruoyi.service.TemplatesService;
import com.ruoyi.util.MinioUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.InputStream;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.UUID;

@Slf4j
@RestController
@RequestMapping("/api/template")
public class TemplatesController extends BaseController {
    @Autowired
    private TemplatesService templatesService;
    @Autowired
    private MinioUtil minioUtil;

    @Value("${minio.endpoint}")
    private String endpoint;

    /**
     * MinIO存储桶名称，从配置文件中注入
     * 配置项：minio.bucket-name
     */
    @Value("${minio.bucket-name}")
    private String bucketName;

    /**
     * OnlyOffice回调接口
     * 文档编辑完成后，OnlyOffice会向此接口发送保存请求
     */
    @PostMapping("/callback")
    public ResponseEntity<JSONObject> callback(@RequestBody OnlyOfficeCallbackDTO callbackDTO,
                                               HttpServletRequest request) {
        log.info("===== 收到OnlyOffice回调 =====");
        JSONObject result = new JSONObject();
        result.put("error", 0);

        try {
            if ("2".equals(callbackDTO.getStatus())) {
                String key = callbackDTO.getKey();
                InputStream inputStream = new URL(callbackDTO.getUrl()).openStream();

                if (key.startsWith("edit_")) {
                    // 【编辑操作】
                    String[] keyParts = key.split("_");
                    if (keyParts.length < 3) {
                        log.error("编辑操作的key格式错误：{}", key);
                        inputStream.close();
                        return ResponseEntity.ok(result);
                    }

                    Long templateId = Long.parseLong(keyParts[1]);
                    JrTemplates template = templatesService.getById(templateId);
                    if (template == null) {
                        log.error("编辑的模板不存在，ID：{}", templateId);
                        inputStream.close();
                        return ResponseEntity.ok(result);
                    }

                    // 提取相对路径
                    String relativePath = minioUtil.extractRelativePath(template.getFilePath());

                    // 上传文件并获取完整URL
                    String storedFileUrl = minioUtil.uploadFileTemplate(inputStream, relativePath, getContentType(FilenameUtils.getExtension(callbackDTO.getUrl())));

                    // 更新数据库记录
                    template.setFilePath(storedFileUrl);
                    template.setUpdateTime(new Date());
                    template.setName(extractTemplateName(key));
                    templatesService.updateById(template);

                } else {
                    // 【新建操作】
                    String templateName = extractTemplateName(key); // 先提取正确的模板名称
                    String fileType = FilenameUtils.getExtension(callbackDTO.getUrl());
                    String documentType = getDocumentType(fileType);

                    // 处理模板名称中的特殊字符（避免路径错误）
                    String safeFileName = templateName
                            .replaceAll("[^a-zA-Z0-9_\\-\\u4e00-\\u9fa5]", "") // 保留字母、数字、下划线、中文
                            .replaceAll("\\s+", "_"); // 空格替换为下划线

                    // 生成路径：templates/文档类型/日期/安全文件名_UUID.扩展名
                    String objectName = String.format(
                            "templates/%s/%s/%s_%s.%s",
                            documentType,
                            new SimpleDateFormat("yyyyMMdd").format(new Date()),
                            safeFileName, // 使用处理后的模板名称
                            UUID.randomUUID().toString().substring(0, 8), // 短UUID避免重名
                            fileType
                    );

                    // 上传文件并保存数据库（此时名称和路径均关联模板名称）
                    String storedFileUrl = minioUtil.uploadFileTemplate(inputStream, objectName, getContentType(fileType));
                    JrTemplates newTemplate = new JrTemplates();
                    newTemplate.setName(templateName); // 存入前端输入的名称
                    newTemplate.setFileType(fileType);
                    newTemplate.setDocumentType(documentType);
                    newTemplate.setFilePath(storedFileUrl);
                    newTemplate.setCategory(documentType);
                    templatesService.saveTemplate(newTemplate);
                }
                inputStream.close();
            }
        } catch (Exception e) {
            result.put("error", 1);
            log.error("回调处理失败", e);
        }
        return ResponseEntity.ok(result);
    }

    private String extractTemplateName(String key) {
        String[] parts = key.split("_");
        // 区分新建和编辑的key格式
        if (key.startsWith("edit_")) {
            // 编辑key格式：edit_{id}_{时间戳}_{名称}，从索引3提取
            if (parts.length >= 4) {
                return String.join("_", Arrays.copyOfRange(parts, 3, parts.length));
            }
        } else {
            // 新建key格式：new_{时间戳}_{名称}，从索引2提取
            if (parts.length >= 3) {
                return String.join("_", Arrays.copyOfRange(parts, 2, parts.length));
            }
        }
        // 格式错误时使用默认名称
        return "未命名模板_" + System.currentTimeMillis();
    }

    /**
     * 根据文件类型获取文档类型
     */
    private String getDocumentType(String fileType) {
        switch (fileType.toLowerCase()) {
            case "docx": return "text";
            case "xlsx": return "spreadsheet";
            case "pptx": return "presentation";
            default: return "other";
        }
    }

    /**
     * 获取文件MIME类型
     */
    private String getContentType(String fileType) {
        switch (fileType.toLowerCase()) {
            case "docx": return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
            case "xlsx": return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
            case "pptx": return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
            default: return "application/octet-stream";
        }
    }
    /**
     *  删除模板
     */
    @DeleteMapping("/{templateId}")
    public AjaxResult deleteTemplate(@PathVariable Long templateId){
        return toAjax(templatesService.deleteById(templateId));
    }

    /**
     * 获取最近修改的模板列表
     */
    @GetMapping("/recent")
    public AjaxResult getRecentTemplates() {
        List<JrTemplates> recentTemplates = templatesService.getRecentTemplates();
        return AjaxResult.success(recentTemplates);
    }

    @GetMapping("/list")
    public TableDataInfo findAllTemplate(JrTemplates templates)
    {
        startPage();
        List<JrTemplates> list = templatesService.selectTemplateList(templates);
        return getDataTable(list);
    }
}
